home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / Onboard / Keyboard.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  9.4 KB  |  298 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import gtk
  5. import gobject
  6. import gconf
  7. import string
  8. from KeyGtk import *
  9. import KeyCommon
  10. sidebarWidth = 60
  11.  
  12. try:
  13.     from Onboard.utils import run_script, keysyms
  14. except DeprecationWarning:
  15.     pass
  16.  
  17.  
  18. class Keyboard(gtk.DrawingArea):
  19.     '''Cairo based keyboard widget'''
  20.     
  21.     def __init__(self, sok):
  22.         gtk.DrawingArea.__init__(self)
  23.         self.mods = {
  24.             1: 0,
  25.             2: 0,
  26.             4: 0,
  27.             8: 0,
  28.             16: 0,
  29.             32: 0,
  30.             64: 0,
  31.             128: 0 }
  32.         self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.LEAVE_NOTIFY_MASK)
  33.         self.connect('expose_event', self.expose)
  34.         self.connect('button_press_event', self.mouse_button_press)
  35.         self.connect('button_release_event', self.mouse_button_release)
  36.         self.connect('leave-notify-event', self.cb_leave_notify)
  37.         self.sok = sok
  38.         self.activePane = None
  39.         self.active = None
  40.         self.scanning = False
  41.         self.scanningInterval = 1
  42.         self.scanningActive = None
  43.         self.stuck = []
  44.         self.altLocked = False
  45.         self.tabKeys = []
  46.         self.panes = []
  47.         self.tabKeys.append(BaseTabKey(self, sidebarWidth))
  48.         self.queue_draw()
  49.  
  50.     
  51.     def set_basePane(self, basePane):
  52.         self.basePane = basePane
  53.  
  54.     
  55.     def add_pane(self, pane):
  56.         self.panes.append(pane)
  57.         self.tabKeys.append(TabKey(self, sidebarWidth, pane))
  58.  
  59.     
  60.     def cb_leave_notify(self, widget, grabbed):
  61.         gtk.gdk.pointer_ungrab()
  62.         if self.active:
  63.             if self.scanningActive:
  64.                 self.active = None
  65.                 self.scanningActive = None
  66.             else:
  67.                 self.release_key(self.active)
  68.             self.queue_draw()
  69.         
  70.         return True
  71.  
  72.     
  73.     def utf8_to_unicode(self, utf8Char):
  74.         return ord(utf8Char.decode('utf-8'))
  75.  
  76.     
  77.     def scan_tick(self):
  78.         if self.scanningActive:
  79.             self.scanningActive.beingScanned = False
  80.         
  81.         if self.activePane:
  82.             pane = self.activePane
  83.         else:
  84.             pane = self.basePane
  85.         if not self.scanningNoY == None:
  86.             self.scanningNoY = (self.scanningNoY + 1) % len(pane.columns[self.scanningNoX])
  87.         else:
  88.             self.scanningNoX = (self.scanningNoX + 1) % len(pane.columns)
  89.         if self.scanningNoY == None:
  90.             y = 0
  91.         else:
  92.             y = self.scanningNoY
  93.         self.scanningActive = pane.columns[self.scanningNoX][y]
  94.         self.scanningActive.beingScanned = True
  95.         self.queue_draw()
  96.         return True
  97.  
  98.     
  99.     def reset_scan(self):
  100.         if self.scanningActive:
  101.             self.scanningActive.beingScanned = False
  102.         
  103.         self.scanningTimeId = None
  104.         self.scanningNoX = None
  105.         self.scanningNoY = None
  106.         self.queue_draw()
  107.  
  108.     
  109.     def mouse_button_press(self, widget, event):
  110.         gtk.gdk.pointer_grab(self.window, True)
  111.         if event.type == gtk.gdk.BUTTON_PRESS:
  112.             self.active = None
  113.             if self.scanning and self.basePane.columns:
  114.                 if self.scanningTimeId:
  115.                     if not self.scanningNoY == None:
  116.                         self.press_key(self.scanningActive)
  117.                         gobject.source_remove(self.scanningTimeId)
  118.                         self.reset_scan()
  119.                     else:
  120.                         self.scanningNoY = -1
  121.                         gobject.source_remove(self.scanningTimeId)
  122.                         self.scanningTimeId = gobject.timeout_add(self.scanningInterval, self.scan_tick)
  123.                 else:
  124.                     self.scanningTimeId = gobject.timeout_add(self.scanningInterval, self.scan_tick)
  125.                     self.scanningNoX = -1
  126.             elif self.activePane:
  127.                 for key in self.activePane.keys.values():
  128.                     self.is_key_pressed(key, widget, event)
  129.                 
  130.             else:
  131.                 for key in self.basePane.keys.values():
  132.                     self.is_key_pressed(key, widget, event)
  133.                 
  134.             for key in self.tabKeys:
  135.                 self.is_key_pressed(key, widget, event)
  136.             
  137.         
  138.         return True
  139.  
  140.     
  141.     def is_key_pressed(self, key, widget, event):
  142.         if key.pointWithinKey(widget, event.x, event.y):
  143.             self.press_key(key)
  144.         
  145.  
  146.     
  147.     def mouse_button_release(self, widget, event):
  148.         if self.active:
  149.             self.release_key(self.active)
  150.             if len(self.stuck) > 0:
  151.                 for stick in self.stuck:
  152.                     self.release_key(stick)
  153.                 
  154.                 self.stuck = []
  155.             
  156.             self.active = None
  157.         
  158.         self.queue_draw()
  159.         return True
  160.  
  161.     
  162.     def press_key(self, key):
  163.         if not key.on:
  164.             if self.mods[8]:
  165.                 self.altLocked = True
  166.                 self.sok.vk.lock_mod(8)
  167.             
  168.             if key.sticky == True:
  169.                 self.stuck.append(key)
  170.             else:
  171.                 self.active = key
  172.             key.on = True
  173.             self.locked = []
  174.             if key.action_type == KeyCommon.CHAR_ACTION:
  175.                 self.sok.vk.press_unicode(self.utf8_to_unicode(key.action))
  176.             elif key.action_type == KeyCommon.KEYSYM_ACTION:
  177.                 self.sok.vk.press_keysym(key.action)
  178.             elif key.action_type == KeyCommon.MODIFIER_ACTION:
  179.                 mod = key.action
  180.                 if not mod == 8:
  181.                     self.sok.vk.lock_mod(mod)
  182.                 
  183.                 self.mods[mod] += 1
  184.             elif key.action_type == KeyCommon.MACRO_ACTION:
  185.                 
  186.                 try:
  187.                     mString = self.sok.macros[string.atoi(key.action)]
  188.                     if mString:
  189.                         for c in mString:
  190.                             char = self.utf8_to_unicode(c)
  191.                             self.sok.vk.press_unicode(char)
  192.                             self.sok.vk.release_unicode(char)
  193.                         
  194.                         return None
  195.                 except IndexError:
  196.                     pass
  197.  
  198.                 dialog = gtk.Dialog('No snippet', self.sok.window, 0, ('_Save snippet', gtk.RESPONSE_OK, '_Cancel', gtk.RESPONSE_CANCEL))
  199.                 dialog.vbox.add(gtk.Label('No snippet for this button,\nType new snippet'))
  200.                 macroEntry = gtk.Entry()
  201.                 dialog.connect('response', self.cb_dialog_response, string.atoi(key.action), macroEntry)
  202.                 macroEntry.connect('activate', self.cb_macroEntry_activate, string.atoi(key.action), dialog)
  203.                 dialog.vbox.pack_end(macroEntry)
  204.                 dialog.show_all()
  205.             elif key.action_type == KeyCommon.KEYCODE_ACTION:
  206.                 self.sok.vk.press_keycode(key.action)
  207.             elif key.action_type == KeyCommon.SCRIPT_ACTION:
  208.                 run_script(key.action, self.sok)
  209.             else:
  210.                 for k in self.tabKeys:
  211.                     if k.pane == self.activePane:
  212.                         k.on = False
  213.                         k.stuckOn = False
  214.                         continue
  215.                 
  216.                 self.activePane = key.pane
  217.         elif key in self.stuck:
  218.             key.stuckOn = True
  219.             self.stuck.remove(key)
  220.         else:
  221.             key.stuckOn = False
  222.             self.release_key(key)
  223.         self.queue_draw()
  224.  
  225.     
  226.     def cb_dialog_response(self, widget, response, macroNo, macroEntry):
  227.         self.set_new_macro(macroNo, response, macroEntry, widget)
  228.  
  229.     
  230.     def cb_macroEntry_activate(self, widget, macroNo, dialog):
  231.         self.set_new_macro(macroNo, gtk.RESPONSE_OK, widget, dialog)
  232.  
  233.     
  234.     def set_new_macro(self, macroNo, response, macroEntry, dialog):
  235.         if response == gtk.RESPONSE_OK:
  236.             if macroNo > len(self.sok.macros) - 1:
  237.                 for n in range(macroNo + 1 - len(self.sok.macros)):
  238.                     self.sok.macros.append('')
  239.                 
  240.             
  241.             self.sok.macros[macroNo] = macroEntry.get_text()
  242.             self.sok.gconfClient.set_list('/apps/sok/macros', gconf.VALUE_STRING, self.sok.macros)
  243.         
  244.         dialog.destroy()
  245.  
  246.     
  247.     def release_key(self, key):
  248.         if key.action_type == KeyCommon.CHAR_ACTION:
  249.             self.sok.vk.release_unicode(self.utf8_to_unicode(key.action))
  250.         elif key.action_type == KeyCommon.KEYSYM_ACTION:
  251.             self.sok.vk.release_keysym(key.action)
  252.         elif key.action_type == KeyCommon.MODIFIER_ACTION:
  253.             mod = key.action
  254.             if not mod == 8:
  255.                 self.sok.vk.unlock_mod(mod)
  256.             
  257.             self.mods[mod] -= 1
  258.         elif key.action_type == KeyCommon.KEYCODE_ACTION:
  259.             self.sok.vk.release_keycode(key.action)
  260.         elif key.action_type == KeyCommon.MACRO_ACTION or key.action_type == KeyCommon.SCRIPT_ACTION:
  261.             pass
  262.         else:
  263.             self.activePane = None
  264.         if self.altLocked:
  265.             self.altLocked = False
  266.             self.sok.vk.unlock_mod(8)
  267.         
  268.         gobject.idle_add(self.release_key_idle, key)
  269.  
  270.     
  271.     def release_key_idle(self, key):
  272.         key.on = False
  273.         self.queue_draw()
  274.         return False
  275.  
  276.     
  277.     def expose(self, widget, event):
  278.         context = widget.window.cairo_create()
  279.         context.set_line_width(1.1)
  280.         size = self.get_allocation()
  281.         self.kbwidth = size.width - sidebarWidth
  282.         self.height = size.height
  283.         context.set_source_rgba(float(self.basePane.rgba[0]), float(self.basePane.rgba[1]), float(self.basePane.rgba[2]), float(self.basePane.rgba[3]))
  284.         context.paint()
  285.         self.basePane.paint(context, self.kbwidth, self.height)
  286.         if self.activePane:
  287.             context.rectangle(0, 0, self.kbwidth, self.height)
  288.             context.set_source_rgba(float(self.activePane.rgba[0]), float(self.activePane.rgba[1]), float(self.activePane.rgba[2]), float(self.activePane.rgba[3]))
  289.             context.fill()
  290.             self.activePane.paint(context, self.kbwidth, self.height)
  291.         
  292.         for key in self.tabKeys:
  293.             key.paint(context)
  294.         
  295.         return True
  296.  
  297.  
  298.